<?php
/*=======================================================================
 // File:  		 JPGRAPH_LINE.PHP
 // Description: Line plot extension for JpGraph
 // Created:  	 2001-01-08
 // Ver:  		 $Id: jpgraph_line.php 1921 2009-12-11 11:46:39Z ljp $
 //
 // Copyright (c) Asial Corporation. All rights reserved.
 //========================================================================
 */

require_once ('jpgraph_plotmark.inc.php');

// constants for the (filled) area
DEFINE("LP_AREA_FILLED", true);
DEFINE("LP_AREA_NOT_FILLED", false);
DEFINE("LP_AREA_BORDER",false);
DEFINE("LP_AREA_NO_BORDER",true);

//===================================================
// CLASS LinePlot
// Description:
//===================================================
class LinePlot extends Plot{
	public $mark=null;
	protected $filled=false;
	protected $fill_color='blue';
	protected $step_style=false, $center=false;
	protected $line_style=1; // Default to solid
	protected $filledAreas = array(); // array of arrays(with min,max,col,filled in them)
	public $barcenter=false;  // When we mix line and bar. Should we center the line in the bar.
	protected $fillFromMin = false, $fillFromMax = false;
	protected $fillgrad=false,$fillgrad_fromcolor='navy',$fillgrad_tocolor='silver',$fillgrad_numcolors=100;
	protected $iFastStroke=false;

	//---------------
	// CONSTRUCTOR
	function LinePlot($datay,$datax=false) {
		parent::__construct($datay,$datax);
		$this->mark = new PlotMark() ;
		$this->color = ColorFactory::getColor();
		$this->fill_color = $this->color;
	}
	//---------------
	// PUBLIC METHODS

	function SetFilled($aFlg=true) {
		$this->filled = $aFlg;
	}

	function SetBarCenter($aFlag=true) {
		$this->barcenter=$aFlag;
	}

	function SetStyle($aStyle) {
		$this->line_style=$aStyle;
	}

	function SetStepStyle($aFlag=true) {
		$this->step_style = $aFlag;
	}

	function SetColor($aColor) {
		parent::SetColor($aColor);
	}

	function SetFillFromYMin($f=true) {
		$this->fillFromMin = $f ;
	}

	function SetFillFromYMax($f=true) {
		$this->fillFromMax = $f ;
	}

	function SetFillColor($aColor,$aFilled=true) {
		//$this->color = $aColor;
		$this->fill_color=$aColor;
		$this->filled=$aFilled;
	}

	function SetFillGradient($aFromColor,$aToColor,$aNumColors=100,$aFilled=true) {
		$this->fillgrad_fromcolor = $aFromColor;
		$this->fillgrad_tocolor   = $aToColor;
		$this->fillgrad_numcolors = $aNumColors;
		$this->filled = $aFilled;
		$this->fillgrad = true;
	}

	function Legend($graph) {
		if( $this->legend!="" ) {
			if( $this->filled && !$this->fillgrad ) {
				$graph->legend->Add($this->legend,
				$this->fill_color,$this->mark,0,
				$this->legendcsimtarget,$this->legendcsimalt,$this->legendcsimwintarget);
			}
			elseif( $this->fillgrad ) {
				$color=array($this->fillgrad_fromcolor,$this->fillgrad_tocolor);
				// In order to differentiate between gradients and cooors specified as an RGB triple
				$graph->legend->Add($this->legend,$color,"",-2 /* -GRAD_HOR */,
				$this->legendcsimtarget,$this->legendcsimalt,$this->legendcsimwintarget);
			} else {
				$graph->legend->Add($this->legend,
				$this->color,$this->mark,$this->line_style,
				$this->legendcsimtarget,$this->legendcsimalt,$this->legendcsimwintarget);
			}
		}
	}

	function AddArea($aMin=0,$aMax=0,$aFilled=LP_AREA_NOT_FILLED,$aColor="gray9",$aBorder=LP_AREA_BORDER) {
		if($aMin > $aMax) {
			// swap
			$tmp = $aMin;
			$aMin = $aMax;
			$aMax = $tmp;
		}
		$this->filledAreas[] = array($aMin,$aMax,$aColor,$aFilled,$aBorder);
	}

	// Gets called before any axis are stroked
	function PreStrokeAdjust($graph) {

		// If another plot type have already adjusted the
		// offset we don't touch it.
		// (We check for empty in case the scale is  a log scale
		// and hence doesn't contain any xlabel_offset)
		if( empty($graph->xaxis->scale->ticks->xlabel_offset) || $graph->xaxis->scale->ticks->xlabel_offset == 0 ) {
			if( $this->center ) {
				++$this->numpoints;
				$a=0.5; $b=0.5;
			} else {
				$a=0; $b=0;
			}
			$graph->xaxis->scale->ticks->SetXLabelOffset($a);
			$graph->SetTextScaleOff($b);
			//$graph->xaxis->scale->ticks->SupressMinorTickMarks();
		}
	}

	function SetFastStroke($aFlg=true) {
		$this->iFastStroke = $aFlg;
	}

	function FastStroke($img,$xscale,$yscale,$aStartPoint=0,$exist_x=true) {
		// An optimized stroke for many data points with no extra
		// features but 60% faster. You can't have values or line styles, or null
		// values in plots.
		$numpoints=count($this->coords[0]);
		if( $this->barcenter ) {
			$textadj = 0.5-$xscale->text_scale_off;
		}
		else {
			$textadj = 0;
		}

		$img->SetColor($this->color);
		$img->SetLineWeight($this->weight);
		$pnts=$aStartPoint;
		while( $pnts < $numpoints ) {
			if( $exist_x ) {
				$x=$this->coords[1][$pnts];
			}
			else {
				$x=$pnts+$textadj;
			}
			$xt = $xscale->Translate($x);
			$y=$this->coords[0][$pnts];
			$yt = $yscale->Translate($y);
			if( is_numeric($y) ) {
				$cord[] = $xt;
				$cord[] = $yt;
			}
			elseif( $y == '-' && $pnts > 0 ) {
				// Just ignore
			}
			else {
				JpGraphError::RaiseL(10002);//('Plot too complicated for fast line Stroke. Use standard Stroke()');
			}
			++$pnts;
		} // WHILE

		$img->Polygon($cord,false,true);
	}

	function Stroke($img,$xscale,$yscale) {
		$idx=0;
		$numpoints=count($this->coords[0]);
		if( isset($this->coords[1]) ) {
			if( count($this->coords[1])!=$numpoints ) {
				JpGraphError::RaiseL(2003,count($this->coords[1]),$numpoints);
				//("Number of X and Y points are not equal. Number of X-points:".count($this->coords[1])." Number of Y-points:$numpoints");
			}
			else {
				$exist_x = true;
			}
		}
		else {
			$exist_x = false;
		}

		if( $this->barcenter ) {
			$textadj = 0.5-$xscale->text_scale_off;
		}
		else {
			$textadj = 0;
		}

		// Find the first numeric data point
		$startpoint=0;
		while( $startpoint < $numpoints && !is_numeric($this->coords[0][$startpoint]) ) {
			++$startpoint;
		}

		// Bail out if no data points
		if( $startpoint == $numpoints ) return;

		if( $this->iFastStroke ) {
			$this->FastStroke($img,$xscale,$yscale,$startpoint,$exist_x);
			return;
		}

		if( $exist_x ) {
			$xs=$this->coords[1][$startpoint];
		}
		else {
			$xs= $textadj+$startpoint;
		}

		$img->SetStartPoint($xscale->Translate($xs),
		$yscale->Translate($this->coords[0][$startpoint]));

		if( $this->filled ) {
			if( $this->fillFromMax ) {
				//$max = $yscale->GetMaxVal();
				$cord[$idx++] = $xscale->Translate($xs);
				$cord[$idx++] = $yscale->scale_abs[1];
			}
			else {
				$min = $yscale->GetMinVal();
				if( $min > 0 || $this->fillFromMin ) {
					$fillmin = $yscale->scale_abs[0];//Translate($min);
				}
				else {
					$fillmin = $yscale->Translate(0);
				}

				$cord[$idx++] = $xscale->Translate($xs);
				$cord[$idx++] = $fillmin;
			}
		}
		$xt = $xscale->Translate($xs);
		$yt = $yscale->Translate($this->coords[0][$startpoint]);
		$cord[$idx++] = $xt;
		$cord[$idx++] = $yt;
		$yt_old = $yt;
		$xt_old = $xt;
		$y_old = $this->coords[0][$startpoint];

		$this->value->Stroke($img,$this->coords[0][$startpoint],$xt,$yt);

		$img->SetColor($this->color);
		$img->SetLineWeight($this->weight);
		$img->SetLineStyle($this->line_style);
		$pnts=$startpoint+1;
		$firstnonumeric = false;


		while( $pnts < $numpoints ) {

			if( $exist_x ) {
				$x=$this->coords[1][$pnts];
			}
			else {
				$x=$pnts+$textadj;
			}
			$xt = $xscale->Translate($x);
			$yt = $yscale->Translate($this->coords[0][$pnts]);

			$y=$this->coords[0][$pnts];
			if( $this->step_style ) {
				// To handle null values within step style we need to record the
				// first non numeric value so we know from where to start if the
				// non value is '-'.
				if( is_numeric($y) ) {
					$firstnonumeric = false;
					if( is_numeric($y_old) ) {
						$img->StyleLine($xt_old,$yt_old,$xt,$yt_old);
						$img->StyleLine($xt,$yt_old,$xt,$yt);
					}
					elseif( $y_old == '-' ) {
						$img->StyleLine($xt_first,$yt_first,$xt,$yt_first);
						$img->StyleLine($xt,$yt_first,$xt,$yt);
					}
					else {
						$yt_old = $yt;
						$xt_old = $xt;
					}
					$cord[$idx++] = $xt;
					$cord[$idx++] = $yt_old;
					$cord[$idx++] = $xt;
					$cord[$idx++] = $yt;
				}
				elseif( $firstnonumeric==false ) {
					$firstnonumeric = true;
					$yt_first = $yt_old;
					$xt_first = $xt_old;
				}
			}
			else {
				$tmp1=$y;
				$prev=$this->coords[0][$pnts-1];
				if( $tmp1==='' || $tmp1===NULL || $tmp1==='X' ) $tmp1 = 'x';
				if( $prev==='' || $prev===null || $prev==='X' ) $prev = 'x';

				if( is_numeric($y) || (is_string($y) && $y != '-') ) {
					if( is_numeric($y) && (is_numeric($prev) || $prev === '-' ) ) {
						$img->StyleLineTo($xt,$yt);
					}
					else {
						$img->SetStartPoint($xt,$yt);
					}
				}
				if( $this->filled && $tmp1 !== '-' ) {
					if( $tmp1 === 'x' ) {
						$cord[$idx++] = $cord[$idx-3];
						$cord[$idx++] = $fillmin;
					}
					elseif( $prev === 'x' ) {
						$cord[$idx++] = $xt;
						$cord[$idx++] = $fillmin;
						$cord[$idx++] = $xt;
						$cord[$idx++] = $yt;
					}
					else {
						$cord[$idx++] = $xt;
						$cord[$idx++] = $yt;
					}
				}
				else {
					if( is_numeric($tmp1)  && (is_numeric($prev) || $prev === '-' ) ) {
						$cord[$idx++] = $xt;
						$cord[$idx++] = $yt;
					}
				}
			}
			$yt_old = $yt;
			$xt_old = $xt;
			$y_old = $y;

			$this->StrokeDataValue($img,$this->coords[0][$pnts],$xt,$yt);

			++$pnts;
		}

		if( $this->filled  ) {
			$cord[$idx++] = $xt;
			if( $this->fillFromMax ) {
				$cord[$idx++] = $yscale->scale_abs[1];
			}
			else {
				if( $min > 0 || $this->fillFromMin ) {
					$cord[$idx++] = $yscale->Translate($min);
				}
				else {
					$cord[$idx++] = $yscale->Translate(0);
				}
			}
			if( $this->fillgrad ) {
				$img->SetLineWeight(1);
				$grad = new Gradient($img);
				$grad->SetNumColors($this->fillgrad_numcolors);
				$grad->FilledFlatPolygon($cord,$this->fillgrad_fromcolor,$this->fillgrad_tocolor);
				$img->SetLineWeight($this->weight);
			}
			else {
				$img->SetColor($this->fill_color);
				$img->FilledPolygon($cord);
			}
			if( $this->weight > 0 ) {
				$img->SetLineWeight($this->weight);
				$img->SetColor($this->color);
				// Remove first and last coordinate before drawing the line
				// sine we otherwise get the vertical start and end lines which
				// doesn't look appropriate
				$img->Polygon(array_slice($cord,2,count($cord)-4));
			}
		}

		if(!empty($this->filledAreas)) {

			$minY = $yscale->Translate($yscale->GetMinVal());
			$factor = ($this->step_style ? 4 : 2);

			for($i = 0; $i < sizeof($this->filledAreas); ++$i) {
				// go through all filled area elements ordered by insertion
				// fill polygon array
				$areaCoords[] = $cord[$this->filledAreas[$i][0] * $factor];
				$areaCoords[] = $minY;

				$areaCoords =
				array_merge($areaCoords,
				array_slice($cord,
				$this->filledAreas[$i][0] * $factor,
				($this->filledAreas[$i][1] - $this->filledAreas[$i][0] + ($this->step_style ? 0 : 1))  * $factor));
				$areaCoords[] = $areaCoords[sizeof($areaCoords)-2]; // last x
				$areaCoords[] = $minY; // last y

				if($this->filledAreas[$i][3]) {
					$img->SetColor($this->filledAreas[$i][2]);
					$img->FilledPolygon($areaCoords);
					$img->SetColor($this->color);
				}
				// Check if we should draw the frame.
				// If not we still re-draw the line since it might have been
				// partially overwritten by the filled area and it doesn't look
				// very good.
				if( $this->filledAreas[$i][4] ) {
					$img->Polygon($areaCoords);
				}
				else {
					$img->Polygon($cord);
				}

				$areaCoords = array();
			}
		}

		if( $this->mark->type == -1 || $this->mark->show == false )
		return;

		for( $pnts=0; $pnts<$numpoints; ++$pnts) {

			if( $exist_x ) {
				$x=$this->coords[1][$pnts];
			}
			else {
				$x=$pnts+$textadj;
			}
			$xt = $xscale->Translate($x);
			$yt = $yscale->Translate($this->coords[0][$pnts]);

			if( is_numeric($this->coords[0][$pnts]) ) {
				if( !empty($this->csimtargets[$pnts]) ) {
					if( !empty($this->csimwintargets[$pnts]) ) {
						$this->mark->SetCSIMTarget($this->csimtargets[$pnts],$this->csimwintargets[$pnts]);
					}
					else {
						$this->mark->SetCSIMTarget($this->csimtargets[$pnts]);
					}
					$this->mark->SetCSIMAlt($this->csimalts[$pnts]);
				}
				if( $exist_x ) {
					$x=$this->coords[1][$pnts];
				}
				else {
					$x=$pnts;
				}
				$this->mark->SetCSIMAltVal($this->coords[0][$pnts],$x);
				$this->mark->Stroke($img,$xt,$yt);
				$this->csimareas .= $this->mark->GetCSIMAreas();
			}
		}
	}
} // Class


//===================================================
// CLASS AccLinePlot
// Description:
//===================================================
class AccLinePlot extends Plot {
	protected $plots=null,$nbrplots=0;
	private $iStartEndZero=true;
	//---------------
	// CONSTRUCTOR
	function __construct($plots) {
		$this->plots = $plots;
		$this->nbrplots = count($plots);
		$this->numpoints = $plots[0]->numpoints;

		// Verify that all plots have the same number of data points
		for( $i=1; $i < $this->nbrplots; ++$i ) {
			if( $plots[$i]->numpoints != $this->numpoints ) {
				JpGraphError::RaiseL(10003);//('Each plot in an accumulated lineplot must have the same number of data points',0)
			}
		}

		for($i=0; $i < $this->nbrplots; ++$i ) {
			$this->LineInterpolate($this->plots[$i]->coords[0]);
		}
	}

	//---------------
	// PUBLIC METHODS
	function Legend($graph) {
		foreach( $this->plots as $p ) {
			$p->DoLegend($graph);
		}
	}

	function Max() {
		list($xmax) = $this->plots[0]->Max();
		$nmax=0;
		$n = count($this->plots);
		for($i=0; $i < $n; ++$i) {
			$nc = count($this->plots[$i]->coords[0]);
			$nmax = max($nmax,$nc);
			list($x) = $this->plots[$i]->Max();
			$xmax = Max($xmax,$x);
		}
		for( $i = 0; $i < $nmax; $i++ ) {
			// Get y-value for line $i by adding the
			// individual bars from all the plots added.
			// It would be wrong to just add the
			// individual plots max y-value since that
			// would in most cases give to large y-value.
			$y=$this->plots[0]->coords[0][$i];
			for( $j = 1; $j < $this->nbrplots; $j++ ) {
				$y += $this->plots[ $j ]->coords[0][$i];
			}
			$ymax[$i] = $y;
		}
		$ymax = max($ymax);
		return array($xmax,$ymax);
	}

	function Min() {
		$nmax=0;
		list($xmin,$ysetmin) = $this->plots[0]->Min();
		$n = count($this->plots);
		for($i=0; $i < $n; ++$i) {
			$nc = count($this->plots[$i]->coords[0]);
			$nmax = max($nmax,$nc);
			list($x,$y) = $this->plots[$i]->Min();
			$xmin = Min($xmin,$x);
			$ysetmin = Min($y,$ysetmin);
		}
		for( $i = 0; $i < $nmax; $i++ ) {
			// Get y-value for line $i by adding the
			// individual bars from all the plots added.
			// It would be wrong to just add the
			// individual plots min y-value since that
			// would in most cases give to small y-value.
			$y=$this->plots[0]->coords[0][$i];
			for( $j = 1; $j < $this->nbrplots; $j++ ) {
				$y += $this->plots[ $j ]->coords[0][$i];
			}
			$ymin[$i] = $y;
		}
		$ymin = Min($ysetmin,Min($ymin));
		return array($xmin,$ymin);
	}

	// Gets called before any axis are stroked
	function PreStrokeAdjust($graph) {

		// If another plot type have already adjusted the
		// offset we don't touch it.
		// (We check for empty in case the scale is  a log scale
		// and hence doesn't contain any xlabel_offset)

		if( empty($graph->xaxis->scale->ticks->xlabel_offset) ||
		$graph->xaxis->scale->ticks->xlabel_offset == 0 ) {
			if( $this->center ) {
				++$this->numpoints;
				$a=0.5; $b=0.5;
			} else {
				$a=0; $b=0;
			}
			$graph->xaxis->scale->ticks->SetXLabelOffset($a);
			$graph->SetTextScaleOff($b);
			$graph->xaxis->scale->ticks->SupressMinorTickMarks();
		}

	}

	function SetInterpolateMode($aIntMode) {
		$this->iStartEndZero=$aIntMode;
	}

	// Replace all '-' with an interpolated value. We use straightforward
	// linear interpolation. If the data starts with one or several '-' they
	// will be replaced by the the first valid data point
	function LineInterpolate(&$aData) {

		$n=count($aData);
		$i=0;

		// If first point is undefined we will set it to the same as the first
		// valid data
		if( $aData[$i]==='-' ) {
			// Find the first valid data
			while( $i < $n && $aData[$i]==='-' ) {
				++$i;
			}
			if( $i < $n ) {
				for($j=0; $j < $i; ++$j ) {
					if( $this->iStartEndZero )
					$aData[$i] = 0;
					else
					$aData[$j] = $aData[$i];
				}
			}
			else {
				// All '-' => Error
				return false;
			}
		}

		while($i < $n) {
			while( $i < $n && $aData[$i] !== '-' ) {
				++$i;
			}
			if( $i < $n ) {
				$pstart=$i-1;

				// Now see how long this segment of '-' are
				while( $i < $n && $aData[$i] === '-' ) {
					++$i;
				}
				if( $i < $n ) {
					$pend=$i;
					$size=$pend-$pstart;
					$k=($aData[$pend]-$aData[$pstart])/$size;
					// Replace the segment of '-' with a linear interpolated value.
					for($j=1; $j < $size; ++$j ) {
						$aData[$pstart+$j] = $aData[$pstart] + $j*$k ;
					}
				}
				else {
					// There are no valid end point. The '-' goes all the way to the end
					// In that case we just set all the remaining values the the same as the
					// last valid data point.
					for( $j=$pstart+1; $j < $n; ++$j )
					if( $this->iStartEndZero ) {
						$aData[$j] = 0;
					}
					else {
						$aData[$j] = $aData[$pstart] ;
					}
				}
			}
		}
		return true;
	}

	// To avoid duplicate of line drawing code here we just
	// change the y-values for each plot and then restore it
	// after we have made the stroke. We must do this copy since
	// it wouldn't be possible to create an acc line plot
	// with the same graphs, i.e AccLinePlot(array($pl,$pl,$pl));
	// since this method would have a side effect.
	function Stroke($img,$xscale,$yscale) {
		$img->SetLineWeight($this->weight);
		$this->numpoints = count($this->plots[0]->coords[0]);
		// Allocate array
		$coords[$this->nbrplots][$this->numpoints]=0;
		for($i=0; $i<$this->numpoints; $i++) {
			$coords[0][$i]=$this->plots[0]->coords[0][$i];
			$accy=$coords[0][$i];
			for($j=1; $j<$this->nbrplots; ++$j ) {
				$coords[$j][$i] = $this->plots[$j]->coords[0][$i]+$accy;
				$accy = $coords[$j][$i];
			}
		}
		for($j=$this->nbrplots-1; $j>=0; --$j) {
			$p=$this->plots[$j];
			for( $i=0; $i<$this->numpoints; ++$i) {
				$tmp[$i]=$p->coords[0][$i];
				$p->coords[0][$i]=$coords[$j][$i];
			}
			$p->Stroke($img,$xscale,$yscale);
			for( $i=0; $i<$this->numpoints; ++$i) {
				$p->coords[0][$i]=$tmp[$i];
			}
			$p->coords[0][]=$tmp;
		}
	}
} // Class


/* EOF */
?>
